#include ".\assignmentclass.h"


void Dictionnary::destroy(vectorTree* vT){	
	if(vT){
		destroy(vT->Next);
		vT->Next = NULL;
		delete vT->Word;
		delete vT->Definition;
	}
}


Dictionnary::Dictionnary( ):Begin(NULL){ m_size = 0;}


Dictionnary::Dictionnary(const vector& v1, const vector& v2){
	vector* Word	= new vector(v1);
	vector* Def		= new vector(v2);
	this->Begin = new vectorTree(Word, Def);
	m_size = 1;

}
Dictionnary::Dictionnary(const Dictionnary& AC):Begin(NULL),m_size(0){
	for(int i=0; i<AC.size( ); i++)
		insert(AC[i]);
}

Dictionnary::~Dictionnary(void)
{
	destroy(this->Begin);
}
const Dictionnary& Dictionnary::operator=(const Dictionnary& Dic){
	destroy( Begin );
	Begin=NULL;
	for(int i=0; i<Dic.size( ); i++)
		insert(Dic[i]);
	return *this;
}
bool Dictionnary::operator==(const Dictionnary& Dic) const{
	if(size( ) != Dic.size( )) return false;
	for(int i=0; i<size( ); i++){
		if(!(*(this->operator [](i).Word) == *(Dic[i].Word))) return false;
		if(!(*(this->operator [](i).Definition) == *(Dic[i].Definition))) return false;
	}
	return true;

}
const vectorTree& Dictionnary::operator[](size_type n) const{
	if((n<0)||(n>=size( ))) throw "out of bound exception";
	if(!Begin) throw "Empty Dictionnary";
	int i=0;
	vectorTree* Current = Begin;
	while((i<n)&&(Current->Next)){Current = Current->Next; i++;}
	if((i==n)&&(Current)) return *Current;

}
void Dictionnary::insert(const vectorTree& vT){
	vectorTree* NewNode = new vectorTree(new vector(*(vT.Word)), new vector(*(vT.Definition)));
	if(!Begin){
		Begin = NewNode;
		Begin->Next = NULL;
		return;
	}
	if(*(vT.Word) < *(Begin->Word)){		
		NewNode->Next = Begin;
		Begin = NewNode;
		return;
	}
	vectorTree* Current = Begin;
	vectorTree* Prev;
	while((Current)&& (*(vT.Word)) > (*(Current->Word))){
		Prev = Current;
		Current = Current->Next;
	}
	Prev->Next = NewNode;
	if(Current) NewNode->Next = Current;
	else NewNode->Next = NULL;
	m_size++;
}